The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(2^n, INF).

(0) Obligation:

Runtime Complexity TRS:
The TRS R consists of the following rules:

a__filter(cons(X, Y), 0, M) → cons(0, filter(Y, M, M))
a__filter(cons(X, Y), s(N), M) → cons(mark(X), filter(Y, N, M))
a__sieve(cons(0, Y)) → cons(0, sieve(Y))
a__sieve(cons(s(N), Y)) → cons(s(mark(N)), sieve(filter(Y, N, N)))
a__nats(N) → cons(mark(N), nats(s(N)))
a__zprimes → a__sieve(a__nats(s(s(0))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(0) → 0
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Rewrite Strategy: FULL

(1) DecreasingLoopProof (EQUIVALENT transformation)

The following loop(s) give(s) rise to the lower bound Ω(2ⁿ):
The rewrite sequence
mark(filter(nats(X72712_4), X2, X3)) →⁺ a__filter(cons(mark(mark(X72712_4)), nats(s(mark(X72712_4)))), mark(X2), mark(X3))
gives rise to a decreasing loop by considering the right hand sides subterm at position [0,0,0].
The pumping substitution is [X72712_4 / filter(nats(X72712_4), X2, X3)].
The result substitution is [ ].

The rewrite sequence
mark(filter(nats(X72712_4), X2, X3)) →⁺ a__filter(cons(mark(mark(X72712_4)), nats(s(mark(X72712_4)))), mark(X2), mark(X3))
gives rise to a decreasing loop by considering the right hand sides subterm at position [0,1,0,0].
The pumping substitution is [X72712_4 / filter(nats(X72712_4), X2, X3)].
The result substitution is [ ].

(2) BOUNDS(2^n, INF)

(3) RenamingProof (EQUIVALENT transformation)

Renamed function symbols to avoid clashes with predefined symbol.

(4) Obligation:

Runtime Complexity Relative TRS:
The TRS R consists of the following rules:

a__filter(cons(X, Y), 0', M) → cons(0', filter(Y, M, M))
a__filter(cons(X, Y), s(N), M) → cons(mark(X), filter(Y, N, M))
a__sieve(cons(0', Y)) → cons(0', sieve(Y))
a__sieve(cons(s(N), Y)) → cons(s(mark(N)), sieve(filter(Y, N, N)))
a__nats(N) → cons(mark(N), nats(s(N)))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

S is empty.
Rewrite Strategy: FULL

(5) SlicingProof (LOWER BOUND(ID) transformation)

Sliced the following arguments:
cons/1

(6) Obligation:

Runtime Complexity Relative TRS:
The TRS R consists of the following rules:

a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

S is empty.
Rewrite Strategy: FULL

(7) TypeInferenceProof (BOTH BOUNDS(ID, ID) transformation)

Infered types.

(8) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

(9) OrderProof (LOWER BOUND(ID) transformation)

Heuristically decided to analyse the following defined symbols:
mark, a__sieve, a__nats, a__zprimes

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(10) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

The following defined symbols remain to be analysed:
a__sieve, mark, a__nats, a__zprimes

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(11) NoRewriteLemmaProof (LOWER BOUND(ID) transformation)

Could not prove a rewrite lemma for the defined symbol a__sieve.

(12) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

The following defined symbols remain to be analysed:
mark, a__nats, a__zprimes

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(13) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Induction Base:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(0)) →_R^Ω(1)
0'

Induction Step:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(n15_0, 1))) →_R^Ω(1)
cons(mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0))) →_IH
cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(c16_0))

We have rt ∈ Ω(n¹) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n).

(14) Complex Obligation (BEST)

(15) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Lemmas:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

The following defined symbols remain to be analysed:
a__nats, a__sieve, a__zprimes

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(16) NoRewriteLemmaProof (LOWER BOUND(ID) transformation)

Could not prove a rewrite lemma for the defined symbol a__nats.

(17) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Lemmas:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

The following defined symbols remain to be analysed:
a__zprimes, a__sieve

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(18) NoRewriteLemmaProof (LOWER BOUND(ID) transformation)

Could not prove a rewrite lemma for the defined symbol a__zprimes.

(19) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Lemmas:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

The following defined symbols remain to be analysed:
a__sieve

They will be analysed ascendingly in the following order:
mark = a__sieve
mark = a__nats
mark = a__zprimes
a__sieve = a__nats
a__sieve = a__zprimes
a__nats = a__zprimes

(20) NoRewriteLemmaProof (LOWER BOUND(ID) transformation)

Could not prove a rewrite lemma for the defined symbol a__sieve.

(21) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Lemmas:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

No more defined symbols left to analyse.

(22) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

(23) BOUNDS(n^1, INF)

(24) Obligation:

TRS:
Rules:
a__filter(cons(X), 0', M) → cons(0')
a__filter(cons(X), s(N), M) → cons(mark(X))
a__sieve(cons(0')) → cons(0')
a__sieve(cons(s(N))) → cons(s(mark(N)))
a__nats(N) → cons(mark(N))
a__zprimes → a__sieve(a__nats(s(s(0'))))
mark(filter(X1, X2, X3)) → a__filter(mark(X1), mark(X2), mark(X3))
mark(sieve(X)) → a__sieve(mark(X))
mark(nats(X)) → a__nats(mark(X))
mark(zprimes) → a__zprimes
mark(cons(X1)) → cons(mark(X1))
mark(0') → 0'
mark(s(X)) → s(mark(X))
a__filter(X1, X2, X3) → filter(X1, X2, X3)
a__sieve(X) → sieve(X)
a__nats(X) → nats(X)
a__zprimes → zprimes

Types:
a__filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
cons :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
0' :: cons:0':s:filter:sieve:nats:zprimes
s :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
mark :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
a__zprimes :: cons:0':s:filter:sieve:nats:zprimes
filter :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
sieve :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
nats :: cons:0':s:filter:sieve:nats:zprimes → cons:0':s:filter:sieve:nats:zprimes
zprimes :: cons:0':s:filter:sieve:nats:zprimes
hole_cons:0':s:filter:sieve:nats:zprimes1_0 :: cons:0':s:filter:sieve:nats:zprimes
gen_cons:0':s:filter:sieve:nats:zprimes2_0 :: Nat → cons:0':s:filter:sieve:nats:zprimes

Lemmas:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

Generator Equations:
gen_cons:0':s:filter:sieve:nats:zprimes2_0(0) ⇔ 0'
gen_cons:0':s:filter:sieve:nats:zprimes2_0(+(x, 1)) ⇔ cons(gen_cons:0':s:filter:sieve:nats:zprimes2_0(x))

No more defined symbols left to analyse.

(25) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
mark(gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0)) → gen_cons:0':s:filter:sieve:nats:zprimes2_0(n15_0), rt ∈ Ω(1 + n15₀)

(26) BOUNDS(n^1, INF)